package haggisworld;

import java.util.Collections;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Observable;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Kenan Brahimi
 */
public class Spiel extends Observable {

    KartenEigenschaften kartenE;
    LinkedList<Karte> haggis = new LinkedList();
    LinkedList<Karte> gespielteKarten = new LinkedList();
    LinkedList<Karte> tischkarten = new LinkedList();
    SpielObjekt startobjekt;
    SpielObjekt objekt;
    int anzSpieler = 0;
    int punkteStand1 = 0;
    int punkteStand2 = 0;
    int runde = 1;
    int spielRunde = 1;
    int stichGewinner;

    public Spiel() {
        startobjekt = new SpielObjekt();
        startobjekt = verteileKarten(1);
        this.haggis = this.startobjekt.getKarten(2);
        System.out.println("Neues Spiel() gestartet");
    }

    /**
     * Getter für Spiel
     *
     * @return das Aktuelle Spiel
     */
    public Spiel getSpiel() {
        return new Spiel();
    }

    /**
     * Getter für Startobjekt
     *
     * @return StartObjekt
     */
    public SpielObjekt getStartObjekt() {
        return this.startobjekt;
    }

    /**
     * Getter für SpielObjekt
     *
     * @return SpielObjekt
     */

    public SpielObjekt getObjekt() {
        return this.objekt;
    }

    public static void main(String[] args) {
    }

    /**
     * Berechnet die Punktezahl der übertragenen Karten.
     *
     * @author Benjamin Loosli bei allen Punktemethoden
     * @return Punktezahl
     */
    public int berechnePunkte() {
        int punkte = 0;
        ListIterator<Karte> li = gespielteKarten.listIterator();
        while (li.hasNext()) {
            Karte kk = li.next();
            punkte = punkte + kk.getPunkte();
        }
        gespielteKarten.removeAll(gespielteKarten);
        return punkte;
    }

    /**
     * Diese Methode berechnet die Restkarten des Verlierers und gibt dabei für
     * jede Karte 5 Punkte dem Gewinner.
     *
     * @param kartenObjekt des Spielzugs mit Karten
     * @return Berechnete Punkte der Fünfpunkte-Regel
     */
    public int fuenfpunkteregel(SpielObjekt kartenObjekt) {
        int punkte = kartenObjekt.getKarten(0).size();
        int berechnetePunkte = punkte * 5;
        return berechnetePunkte;
    }

    /**
     * Berechnet die Punkte des HaggisStapels
     *
     * @return Berechnete Haggis-Punkte
     */
    public int haggisPunkte() {
        int haggisPunkte = 0;
        ListIterator<Karte> li = haggis.listIterator();
        while (li.hasNext()) {
            Karte kk = li.next();
            haggisPunkte = haggisPunkte + kk.getPunkte();
        }
        gespielteKarten.removeAll(gespielteKarten);
        haggis.clear();
        return haggisPunkte;
    }

    /**
     * Überprüft, welche Jokerkarten gespielt wurden
     *
     * @param objekt SpielObjekt mit allen gespielten Karten eines Zugs.
     * @return LinkedList<Karte> der gespielten Bonuskarten
     */
    private LinkedList<Karte> gespielteBonuskarten(SpielObjekt objekt) {
        LinkedList<Karte> karten = objekt.getKarten(0);
        LinkedList<Karte> bonuskarten = new LinkedList();
        if (karten != null) {
            ListIterator<Karte> iter = karten.listIterator();
            while (iter.hasNext()) {
                Karte k = iter.next();
                if (k.getName().equals("Bube") || k.getName().equals("Dame") || k.getName().equals("Koenig")) {
                    bonuskarten.add(k);
                }
            }
        }
        return bonuskarten;
    }

    /**
     * Diese Methode startet das Spiel.
     *
     */
    public void starteSpiel() {
        SpielObjekt o = this.getStartObjekt();
        setChanged();
        notifyObservers(o);
    }

    /**
     * Empfängt den Spielbefehl jedes Spielers
     *
     * @author Kenan Brahimi, Andreas Miksik
     * @param erhaltenesObjekt SpielObjekt des aktuellen Spielbefehls
     */
    public void erhalteSpielbefehl(SpielObjekt erhaltenesObjekt) {

        if (erhaltenesObjekt.getNachricht().equals("STARTOBJEKT")) {
            starteSpiel();
        } else if (erhaltenesObjekt.getNachricht().equals("PASS")) {
            int punkte = berechnePunkte();
            int spielerAmZug = 0;
            // Wenn Pass gedrückt wird werden die Punkte ausgerechnet.
            SpielObjekt sendePunktestand = new SpielObjekt();
            if (erhaltenesObjekt.getAmZug() == 2) {
                spielerAmZug = 1;
                punkteStand1 = punkteStand1 + punkte;
                sendePunktestand.setPunkte(punkteStand1);
            } else {
                spielerAmZug = 2;
                punkteStand2 = punkteStand2 + punkte;
                sendePunktestand.setPunkte(punkteStand2);
            }
            if (checkPunktelimit()) {
                tischkarten.clear();
                SpielObjekt neuesSpielObjekt = new SpielObjekt("PUNKTE_ERHALTEN");
                erhalteSpielbefehl(neuesSpielObjekt);
            } else {
                tischkarten.clear();
                sendePunktestand.setKarten(null, 0);
                sendePunktestand.setNachricht("SENDE_PUNKTE");
                sendePunktestand.setAmZug(spielerAmZug);
                sendePunktestand.setAn("c" + spielerAmZug);
                setChanged();
                notifyObservers(sendePunktestand);
            }
        } else if (erhaltenesObjekt.getNachricht().equals("SPIELZUG")) {
            if (ueberpruefeSpielzug(erhaltenesObjekt)) {
                tischkarten.removeAll(tischkarten);
                tischkarten = erhaltenesObjekt.getKarten(0);
                ListIterator<Karte> iter = tischkarten.listIterator();
                while (iter.hasNext()) {
                    System.out.println("Überprüfung: " + iter.next().toString());
                }
                if (tischkarten.size() != 0) {
                    gespielteKarten.addAll(tischkarten);
                }
                SpielObjekt sende = new SpielObjekt();
                sende.setKarten(tischkarten, 0);
                sende.setKarten(gespielteBonuskarten(erhaltenesObjekt), 2);
                sende.setNachricht("SPIELZUG GUELTIG");
                sende.setAn(erhaltenesObjekt.getVon());
                int spielerAmZug = 0;
                if (erhaltenesObjekt.getAmZug() == 2) {
                    spielerAmZug = 1;
                } else {
                    spielerAmZug = 2;
                }
                sende.setAmZug(spielerAmZug);
                setChanged();
                notifyObservers(sende);
            } else {
                SpielObjekt sende = new SpielObjekt();
                sende.setNachricht("SPIELZUG_UNGUELTIG");
                sende.setAn(erhaltenesObjekt.getVon());
                setChanged();
                notifyObservers(sende);
            }
        } else if (erhaltenesObjekt.getNachricht().equals("KEINE_KARTEN")) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                Logger.getLogger(Spiel.class.getName()).log(Level.SEVERE, null, ex);
            }
            SpielObjekt verlangeKarten = new SpielObjekt("VERLANGE_KARTEN");
            if (erhaltenesObjekt.getVon().equals("c" + 1)) {
                verlangeKarten.setAn("c" + 2);
            } else {
                verlangeKarten.setAn("c" + 1);
            }
            tischkarten.clear();
            setChanged();
            notifyObservers(verlangeKarten);
        } else if (erhaltenesObjekt.getNachricht().equals("SENDE_HANDKARTEN")) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                System.out.println("SENDE_HANDKARTEN: sleep() failed");
            }
            int fuenfPunkte = fuenfpunkteregel(erhaltenesObjekt);
            int haggisPunkte = haggisPunkte();
            int berechnetePunkte = berechnePunkte();
            System.out.println("Punkte in dieser Runde||| Fünfpunkteregel: " + fuenfPunkte + " | Haggis-Punkte: " + haggisPunkte + " | Handkarten-Punkte: " + berechnetePunkte);
            int rundenPunkte = fuenfPunkte + haggisPunkte + berechnetePunkte;
            SpielObjekt punktewertung = new SpielObjekt("SENDE_PUNKTE");
            if (erhaltenesObjekt.getVon().equals("c" + 1)) {
                punkteStand2 = punkteStand2 + rundenPunkte;
                punktewertung.setAn("c" + 2);
                punktewertung.setPunkte(punkteStand2);
            } else {
                punkteStand1 = punkteStand1 + rundenPunkte;
                punktewertung.setAn("c" + 1);
                punktewertung.setPunkte(punkteStand1);
            }
            if (punkteStand1 <= punkteStand2) {
                punktewertung.setAmZug(1);
            } else {
                punktewertung.setAmZug(2);
            }
            punktewertung.setVon("NEUE_RUNDE");
            setChanged();
            notifyObservers(punktewertung);

        } else if (erhaltenesObjekt.getNachricht().equals("PUNKTE_ERHALTEN")) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                Logger.getLogger(Spiel.class.getName()).log(Level.SEVERE, null, ex);
            }
            runde++;
            tischkarten.clear();
            SpielObjekt neueRunde = new SpielObjekt();
            if (checkPunktelimit()) {
                neueRunde = verteileKarten(1);
                neueRunde.setVon("NEUES_SPIEL");
                tischkarten.clear();
                runde = 1;
                punkteStand1 = 0;
                punkteStand2 = 0;
                spielRunde++;
                neueRunde.setSpiel(spielRunde);
            } else if (punkteStand1 >= punkteStand2) {
                neueRunde = verteileKarten(2);
            } else {
                neueRunde = verteileKarten(1);
            }
            neueRunde.setRunde(runde);
            this.haggis = neueRunde.getKarten(2);
            setChanged();
            notifyObservers(neueRunde);
        } else if (erhaltenesObjekt.getNachricht().equals("VERBINDUNG_UNTERBROCHEN")) {
            setChanged();
            notifyObservers(erhaltenesObjekt);
        }

    }

    /**
     * Überprüft, ob das Punktelimit des Spiels erreicht wurde
     *
     * @return boolean
     */
    private boolean checkPunktelimit() {
        if (punkteStand1 >= 250 || punkteStand2 >= 250) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Überprüft, ob die gespielten Karten höher sind. Wird verwendet um zu
     * überprüfen, ob neuer Spielzug höher als vorgängiger ist.
     *
     * @param karten Gespielte Karten
     * @return int des Kartenwerts des kleinsten Elements.
     */
    private int istHoeher(LinkedList<Karte> karten) {
        int min = 14;
        ListIterator<Karte> iter = karten.listIterator();
        while (iter.hasNext()) {
            int temp = iter.next().getWert();
            if (temp < min) {
                min = temp;
            }
        }
        return min;
    }

    /**
     * Diese Methode überprüft, ob nicht nur Jokerkarten gespielt wurden, was
     * eine Bombe wäre.
     *
     * @param karten gespielte karten
     * @return boolean Spielzug gültig
     */
    private boolean ueberpruefeJokerSpielzug(LinkedList<Karte> karten) {
        ListIterator<Karte> iter = karten.listIterator();
        int count = 0;
        while (iter.hasNext()) {
            Karte k = iter.next();
            if (k.getFarbe().equals("Bube") || k.getFarbe().equals("Dame") || k.getFarbe().equals("Koenig")) {
                count++;
            }
        }
        if ((count >= 2) && (count == karten.size())) {
            return false;
        }
        return true;
    }

    /**
     * Überprüft den Spielzug nach den Spielregeln eines Sets
     *
     * @param karten Gespielte Karten einer Runde
     * @return int der Bestätigung. -1 wenn Spielzug ungültig, max von
     * vorgekommenem Set, bsp. 3er Set.
     */
    private int ueberpruefeSet(LinkedList<Karte> karten) {
        int[][] kommtVor = new int[12][1];
        int max = 0;

        for (int k = 2; k <= 13; k++) {
            int count = 0;
            ListIterator<Karte> iter = karten.listIterator();
            while (iter.hasNext()) {
                if (iter.next().getWert() == k) {
                    count++;
                }
            }
            kommtVor[k - 2][0] = count;
            if (count > max) {
                max = count;
            }

            System.out.println("Die Karte mit der Nummer " + k + " kommt " + count + " mal vor.");
        }

        // Überprüft, ob es entweder 0 Karten mit der gleichen Nummer oder die gleiche Anzahl von max bereits hat.
        for (int z = 0; z < 12; z++) {
            if ((kommtVor[z][0] != 0) && (kommtVor[z][0] != max)) {
                System.out.println("Kommt Vor: " + z + "; Karte:" + kommtVor[z] + " ; " + kommtVor[z][0] + "; max:" + max);
                System.out.println("Zeile 238");
                return -1;
            }
        }
        LinkedList<Karte> setFarben = new LinkedList();
        int letzteKartennummer = 0;
        for (int zz = 0; zz < 12; zz++) {
            System.out.println("LetzteKartennummer: " + letzteKartennummer + " max: " + max);
            if (kommtVor[zz][0] == max && (letzteKartennummer == 0)) {
                letzteKartennummer = zz + 2;
                ListIterator<Karte> itr = karten.listIterator();
                while (itr.hasNext()) {
                    Karte temp = itr.next();
                    if (temp.getWert() == letzteKartennummer) {
                        setFarben.add(temp);
                    }
                }
            } else if (zz == letzteKartennummer + 1 - 2 && kommtVor[zz][0] == max) { // +1 weil nächste, -2 weil zz bei 0 und Karten bei 2 anfangen. Kleinste Karte ist 2, nicht 0.
                int farbVorkommen = 0;
                letzteKartennummer = zz + 2;
                ListIterator<Karte> itr2 = setFarben.listIterator();
                while (itr2.hasNext()) {
                    Karte kkk = itr2.next();
                    ListIterator<Karte> itr3 = karten.listIterator();
                    while (itr3.hasNext()) {
                        Karte kkk2 = itr3.next();
                        if ((kkk2.getFarbe().equals(kkk.getFarbe())) && kkk2.getWert() == letzteKartennummer) {
                            farbVorkommen++;
                        }
                    }
                }
                if (setFarben.size() != farbVorkommen) {
                    System.out.println("Zeile 270 Letzte Kartennummer: " + letzteKartennummer + "zz: " + zz + " setFarben.size()" + setFarben.size() + " FarbVorkommen: " + farbVorkommen);
                    return -1;
                }
            } else if ((letzteKartennummer != 0) && (zz != letzteKartennummer + 1 - 2) && (kommtVor[zz][0] > 0)) {
                System.out.println("Zeile 275");
                return -1;
            }
        }

        return max;
    }

    /**
     * Fügt die Jokerkarten automatisch zu einer Farbe hinzu
     *
     * @param karten Gespielte Karten des aktuellen Spielzugs.
     * @return Gespielte Karten nach automatischer Anpassung.
     */
    private LinkedList<Karte> ordneJokerkarteEin(LinkedList<Karte> karten) {
        ListIterator<Karte> iter = karten.listIterator();
        int gruen = 0;
        int gelb = 0;
        int orange = 0;
        int rot = 0;
        while (iter.hasNext()) {
            Karte k = iter.next();
            String farbe = k.getFarbe();
            switch (farbe) {
                case "Gruen":
                    gruen++;
                    break;
                case "Gelb":
                    gelb++;
                    break;
                case "Orange":
                    orange++;
                    break;
                case "Rot":
                    rot++;
                    break;
            }
        }
        ListIterator<Karte> iterJoker = karten.listIterator();
        while (iterJoker.hasNext()) {
            int[] farbenVorkommen = new int[4];
            farbenVorkommen[0] = gruen;
            farbenVorkommen[1] = gelb;
            farbenVorkommen[2] = orange;
            farbenVorkommen[3] = rot;
            int max = 0;
            for (int z = 0; z < 4; z++) {
                if (farbenVorkommen[z] > max) {
                    max = farbenVorkommen[z];
                }
            }
            Karte jokerKarte = iterJoker.next();
            String jokerFarbe = jokerKarte.getFarbe();
            if (jokerFarbe.equals("Bube") || jokerFarbe.equals("Dame") || jokerFarbe.equals("Koenig")) {
                if ((gruen != 0) && gruen <= max) {
                    iterJoker.remove();
                    jokerKarte.setFarbe("Gruen");
                    iterJoker.add(jokerKarte);
                } else if ((gelb != 0) && gelb <= max) {
                    iterJoker.remove();
                    jokerKarte.setFarbe("Gelb");
                    iterJoker.add(jokerKarte);
                } else if ((orange != 0) && orange <= max) {
                    iterJoker.remove();
                    jokerKarte.setFarbe("Orange");
                    iterJoker.add(jokerKarte);
                } else if ((rot != 0) && rot <= max) {
                    iterJoker.remove();
                    jokerKarte.setFarbe("Rot");
                    iterJoker.add(jokerKarte);
                } else {
                    iterJoker.remove();
                    jokerKarte.setFarbe("Gruen");
                    iterJoker.add(jokerKarte);
                }

            }
        }

        return karten;
    }

    /**
     * Überprüft, ob Spielzug Strasse ist.
     *
     * @author Kenan Brahimi
     *
     * @param karten Gespielte Karten des Spielzugs
     * @return Int als Bestätigung. -1 wenn ungültig, 0 wenn gültig aber keine
     * Strasse, 1 wenn Strasse
     */
    private int ueberpruefeStrasse(LinkedList<Karte> karten) {
        // Sortiere nach Farbe
        if (karten.size() >= 3) {  // Minimale Kartenanzahl für Strasse = 3
            LinkedList<Karte> gruen = new LinkedList();
            LinkedList<Karte> gelb = new LinkedList();
            LinkedList<Karte> orange = new LinkedList();
            LinkedList<Karte> rot = new LinkedList();
            ListIterator<Karte> iter = karten.listIterator();
            Collections.sort(karten, new VergleicheKartenWert());
            int anzKaVoFarb = 0;
            while (iter.hasNext()) {
                Karte k = iter.next();
                String farbe = k.getFarbe();
                switch (farbe) {
                    case "Gruen":
                        gruen.add(k);
                        break;
                    case "Gelb":
                        gelb.add(k);
                        break;
                    case "Orange":
                        orange.add(k);
                        break;
                    case "Rot":
                        rot.add(k);
                        break;
                }
            }

            // Überprüft, ob die Anzahl Karten pro Farbe mit anderen Farben übereinstimmt oder null ist.
            if (anzKaVoFarb != 0 && anzKaVoFarb != gruen.size() && gruen.size() != 0) {
                System.out.println("Zeile 192. anzKaVoFarb = " + anzKaVoFarb + ":::: gruen.size(): " + gruen.size());
                return -1;
            } else if (anzKaVoFarb < gruen.size()) {
                anzKaVoFarb = gruen.size();
            }
            if (anzKaVoFarb != 0 && anzKaVoFarb != gelb.size() && gelb.size() != 0) {
                System.out.println("Zeile 205. anzKaVoFarb = " + anzKaVoFarb + ":::: gruen.size(): " + gelb.size());
                return -1;
            } else if (anzKaVoFarb < gelb.size()) {
                anzKaVoFarb = gelb.size();
            }
            if (anzKaVoFarb != 0 && anzKaVoFarb != orange.size() && orange.size() != 0) {
                System.out.println("Zeile 213. anzKaVoFarb = " + anzKaVoFarb + ":::: gruen.size(): " + orange.size());
                return -1;
            } else if (anzKaVoFarb < orange.size()) {
                anzKaVoFarb = orange.size();
            }
            if (anzKaVoFarb != 0 && anzKaVoFarb != rot.size() && rot.size() != 0) {
                System.out.println("Zeile 222. anzKaVoFarb = " + anzKaVoFarb + ":::: gruen.size(): " + rot.size());
                return -1;
            } else if (anzKaVoFarb < rot.size()) {
                anzKaVoFarb = rot.size();
            }

            int tiefsterWert = 14;

            // Initialisiere ListIterator, welcher alle 4 Farben durchgeht.
            ListIterator<Karte> itr = null;
            for (int i = 0; i < 4; i++) {
                switch (i) {
                    case 0:
                        itr = gruen.listIterator();
                        break;
                    case 1:
                        itr = gelb.listIterator();
                        break;
                    case 2:
                        itr = orange.listIterator();
                        break;
                    case 3:
                        itr = rot.listIterator();
                        break;
                }

                int letzteKartennummer = 0;
                while (itr.hasNext()) {

                    Karte kk = itr.next();
                    if ((kk.getWert() == letzteKartennummer + 1) || (letzteKartennummer == 0)) {
                        if (letzteKartennummer == 0) { // Ergibt True, wenn eine Farbe vorkommt und die erste Karte dieser Farbe iteriert wird.
                            if ((tiefsterWert != 14) && (kk.getWert() != tiefsterWert)) {
                                System.out.println("Zeile 371");
                                return -1;
                            }
                            // Wird nicht ausgeführt, wenn return -1 aufgerufen wurde
                            System.out.println("TiefsterWert = kk.getWert()");
                            tiefsterWert = kk.getWert();
                        }

                        letzteKartennummer = kk.getWert();

                    } else {
                        System.out.println("Zeile 383");
                        return -1;
                    }
                }
            }

            return 1;
        } else if (karten.size() == 2) {
            ListIterator<Karte> itr = karten.listIterator();
            String farbe = "";
            int durchgang = 0;
            while (itr.hasNext()) {
                Karte kk = itr.next();
                System.out.println("kk Farbe: " + kk.getFarbe() + "String Farbe: " + farbe);
                if (durchgang == 0) {
                    farbe = kk.getFarbe();
                    durchgang++;
                    continue;
                }
                if ((durchgang == 1) && (kk.getFarbe().equals(farbe))) {
                    return -1;
                }
            }
        }
        return 0;
    }

    /**
     * Überprüft den Spielzug eines Spielers
     *
     * @param objekt SpielObjekt mit gespielten Karten des Spielzugs.
     * @return Bestätigt korrekten Spielzug oder lehnt ihn ab.
     */
    private boolean ueberpruefeSpielzug(SpielObjekt objekt) {
        LinkedList<Karte> kauberpruf = objekt.getKarten(0);
        if (!ueberpruefeJokerSpielzug(kauberpruf)) {
            return false;
        }
        kauberpruf = ordneJokerkarteEin(kauberpruf);
        System.out.println("Überprüfe Strasse: " + ueberpruefeStrasse(kauberpruf));
        System.out.println("Überprüfe Set: " + ueberpruefeSet(kauberpruf));

        if ((kauberpruf.size() == tischkarten.size()) || tischkarten.size() == 0) {    // Wenn gleich viele Karten gelegt wurden, wie bereits auf tisch, oder Tisch leer (erster Stich)
            if (tischkarten.size() != 0) {
                if ((ueberpruefeSet(kauberpruf) == ueberpruefeSet(tischkarten)) && istHoeher(kauberpruf) > istHoeher(tischkarten)) {
                    return true;
                } else {
                    return false;
                }
            } else if ((ueberpruefeSet(kauberpruf) != -1) && (ueberpruefeStrasse(kauberpruf) != -1)) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    /**
     * Diese Methode verteilt die Karten
     *
     * @return SpielObjekt mit Karten zum verteilen
     */
    public SpielObjekt verteileKarten(int spielerAmZug) {
        SpielObjekt objekt = new SpielObjekt();
        LinkedList<Karte> temp1 = new LinkedList();
        LinkedList<Karte> temp2 = new LinkedList();
        LinkedList<Karte> karten1 = new LinkedList();
        LinkedList<Karte> karten2 = new LinkedList();
        LinkedList<Karte> haggis = new LinkedList();

        kartenE = new KartenEigenschaften();

        temp1 = kartenE.getStandardKarten();   // 0: gemischte Standardkarten ; 1: Bonuskarten;  2: Sp 1; 3: Sp 2; 4: Ha
        temp2 = kartenE.getBonusKarten();

        for (int i = 0; i < 2; i++) {
            if (i == 0) {
                for (int j = 0; j < 14; j++) {
                    karten1.addFirst(temp1.getFirst());
                    temp1.removeFirst();
                }
                for (int k = 0; k < 3; k++) {
                    karten1.addFirst(temp2.getFirst());
                    temp2.removeFirst();
                }
            } else {
                for (int j = 0; j < 14; j++) {
                    karten2.addFirst(temp1.getFirst());
                    temp1.removeFirst();
                }
                for (int k = 0; k < 3; k++) {
                    karten2.addFirst(temp2.getFirst());
                    temp2.removeFirst();
                }
            }
        }
        int restgroesse = temp1.size();
        for (int l = 0; l < restgroesse; l++) {                     // Haggis Deck
            haggis.addFirst(temp1.getFirst());
            temp1.removeFirst();
        }

        objekt.setAmZug(spielerAmZug);
        objekt.setRunde(runde);
        objekt.setKarten(karten1, 0);
        objekt.setKarten(karten2, 1);
        objekt.setKarten(haggis, 2);
        objekt.setNachricht("VERTEILE_KARTEN");
        return objekt;
    }

}
